package com.example.st.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.example.st.common.ResponseResult;
import com.example.st.entity.Bp;
import com.example.st.service.AmapService;
import com.example.st.service.BpService;
import com.example.st.service.GptService;
import com.example.st.service.PushService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.HashMap;
import java.util.Map;

@Slf4j
@Service
public class GptServiceImpl implements GptService {

    @Autowired
    private AmapService amapService;

    @Autowired
    private PushService pushService;

    @Autowired
    private BpService bpService;

    /*public ResponseResult recommend(String uid, String text, String origin, String destination) {
        if (StringUtils.isEmpty(uid) || StringUtils.isEmpty(text) || StringUtils.isEmpty(origin) || StringUtils.isEmpty(destination)) {
            log.error("uid或text或origin或destination不能为空");
            return new ResponseResult<>(-1, "uid或text或origin或destination不能为空", null);
        }

        // 获取路线信息
        Map<String, Object> routeInfo = amapService.getRouteInfo(origin, destination);

        // 构建推送消息请求
        String request = "根据需求帮助我进行交通方式的选择, text内容为需求, routeInfo内容为Json格式的不同交通方式对应的通行时间与花费,其中通行时间是以'时:分:秒'为单位，费用是'元'为单位,你的回答只需要告诉我交通方式(在routeInfo中的四种交通方式driving、walking、transit、bicycling中选择,使用英文),其他任何话都不需要回答。"
                + "\ntext:" + text + "\nrouteInfo:" + routeInfo;

        // 调用推送服务
        ResponseResult result = pushService.pushMessageToXFServer(uid, request);

        if (result != null && result.getCode() == 200) {
            // 请求成功，可以获取 data 字段的数据
            String recommendedType = (String) result.getData(); // 假设 data 是一个字符串类型
            // 现在可以使用 data 变量，这里假设 data 是 "driving"
            log.info("Data received: " + recommendedType);

            Map<String, Object> transportationInfo = (Map<String, Object>) routeInfo.get(recommendedType);
            String duration = (String) transportationInfo.get("duration");
            Double cost = (Double) transportationInfo.get("cost");
            String costStr = cost.toString();

            // 创建 Bp 对象
            Bp bp = new Bp();
            bp.setUid(Long.parseLong(uid));
            bp.setType(recommendedType);
            bp.setOrigin(origin);
            bp.setDestination(destination);
            bp.setDuration(duration);
            bp.setCost(costStr);

            bpService.createBp(bp);

        } else {
            // 请求失败或返回结果不符合预期
            log.info("请求失败或返回结果不符合预期");
        }
        return result;
    }*/
    public ResponseResult recommendPath (String uid, String text, String origin, String destination) {
        if (StringUtils.isEmpty(uid) || StringUtils.isEmpty(text) || StringUtils.isEmpty(origin) || StringUtils.isEmpty(destination)) {
            log.error("uid或text或origin或destination不能为空");
            return new ResponseResult<>(-1, "uid或text或origin或destination不能为空", null);
        }

        // 获取路线信息
        Map<String, Object> routeInfo = amapService.getRouteInfo(origin, destination);

        if (routeInfo == null) {
            log.error("获取路线信息失败或为空");
            return new ResponseResult<>(-1, "获取路线信息失败或为空", null);
        }

        // 构建推送消息请求
        String request = "根据需求帮助我进行交通方式的选择, text内容为需求, routeInfo内容为Json格式的不同交通方式对应的通行时间与花费,其中通行时间是以'时:分:秒'为单位，费用是'元'为单位,你的回答只需要告诉我交通方式(在routeInfo中的四种交通方式driving、walking、transit、bicycling中选择,使用英文),其他任何话都不需要回答。"
                + "\ntext:" + text + "\nrouteInfo:" + routeInfo;

        // 调用推送服务
        ResponseResult result = pushService.pushMessageToXFServer(uid, request);

        if (result != null && result.getCode() == 200) {
            // 请求成功，可以获取 data 字段的数据
            String recommendedType = (String) result.getData(); // 假设 data 是一个字符串类型

            if (recommendedType == null || !routeInfo.containsKey(recommendedType)) {
                log.error("推荐的交通方式为空或不存在于路线信息中");
                return new ResponseResult<>(-1, "推荐的交通方式为空或不存在于路线信息中", null);
            }

            Map<String, Object> transportationInfo = (Map<String, Object>) routeInfo.get(recommendedType);

            if (transportationInfo == null) {
                log.error("获取推荐交通方式的信息失败或为空");
                return new ResponseResult<>(-1, "获取推荐交通方式的信息失败或为空", null);
            }

            String duration = (String) transportationInfo.get("duration");
            Double cost = (Double) transportationInfo.get("cost");


            // 构建包含推荐交通方式信息的 Map
            Map<String, Object> recommendedInfo = new HashMap<>();
            recommendedInfo.put("type", recommendedType);
            recommendedInfo.put("duration", duration);
            recommendedInfo.put("cost", cost);

            result.setData(recommendedInfo);
            //当步行>100km时或者公交线路太近，api失效，设置为驾车或者步行
            if (cost == null && recommendedType.equals("walking")) {
                result.setData("driving");

                Map<String, Object> transportationInfos = (Map<String, Object>) routeInfo.get("driving");
                String durations = (String) transportationInfos.get("duration");
                Double costs = (Double) transportationInfos.get("cost");
                String costsStr = costs.toString();
                // 创建 Bp 对象
                Bp bps = new Bp();
                bps.setUid(Long.parseLong(uid));
                bps.setType("driving");
                bps.setOrigin(origin);
                bps.setDestination(destination);
                bps.setDuration(durations);
                bps.setCost(costsStr);

                bpService.createBp(bps);
                //return result;
            } else if (cost == null && recommendedType.equals("transit")){
                result.setData("walking");

                Map<String, Object> transportationInfoss = (Map<String, Object>) routeInfo.get("walking");
                String durationss = (String) transportationInfoss.get("duration");
                Double costss = (Double) transportationInfoss.get("cost");
                String costssStr = costss.toString();
                // 创建 Bp 对象
                Bp bpss = new Bp();
                bpss.setUid(Long.parseLong(uid));
                bpss.setType("walking");
                bpss.setOrigin(origin);
                bpss.setDestination(destination);
                bpss.setDuration(durationss);
                bpss.setCost(costssStr);

                bpService.createBp(bpss);
                //return result;
            } else {
                String costStr = cost.toString();
                // 创建 Bp 对象
                Bp bp = new Bp();
                bp.setUid(Long.parseLong(uid));
                bp.setType(recommendedType);
                bp.setOrigin(origin);
                bp.setDestination(destination);
                bp.setDuration(duration);
                bp.setCost(costStr);

                bpService.createBp(bp);
            }

        } else {
            // 请求失败或返回结果不符合预期
            log.info("请求失败或返回结果不符合预期");
        }
        return result;
    }

    public ResponseResult recommendDestination (String uid, String text){
        if (StringUtils.isEmpty(uid) || StringUtils.isEmpty(text)) {
            log.error("uid或text不能为空");
            return new ResponseResult<>(-1, "uid或text不能为空", null);
        }

        // 构建推送消息请求
        String request = "根据需求帮助我进行中国目的地的推荐, text内容为需求,你的回答需要以JSON的形式(JSON格式：{\"destination\":xxx,\"attractions\":[{\"spot\":xxx,\"introduction\":xxx},{\"spot\":xxx,\"introduction\":xxx}...]})返回推荐的目的地城市(destination),目的地城市里的景点(attractions数组,各个数组元素中spot代表各个景点名称,introduction代表该景点的相关介绍)其他任何多余的话和前缀都不需要回答,只回答按我要求的JSON格式的内容。"
                + "\ntext:" + text;

        // 调用推送服务
        ResponseResult result = pushService.pushMessageToXFServer(uid, request);

        // 获取推送结果中的数据字段
        Object responseData = result.getData();

        // 获取data字段的值
        String data = responseData.toString( );

        // 判断data字段的内容
       /* if (data.startsWith("```json")) {
            // 如果以 ```json 开头，去掉开头和结尾的标记部分
            int startIndex = data.indexOf("{");
            int endIndex = data.lastIndexOf("}");
            if (startIndex != -1 && endIndex != -1 && endIndex > startIndex) {
                data = data.substring(startIndex, endIndex + 1);
            }
        } else if (data.startsWith("json")) {
            // 如果以 ```json 开头，去掉开头和结尾的标记部分
            int startIndex = data.indexOf("{");
            int endIndex = data.lastIndexOf("}");
            if (startIndex != -1 && endIndex != -1 && endIndex > startIndex) {
                data = data.substring(startIndex, endIndex + 1);
            }
        } else if(!data.startsWith("{")) {
            int startIndex = data.indexOf("{");
            int endIndex = data.lastIndexOf("}");
            if (startIndex != -1 && endIndex != -1 && endIndex > startIndex) {
                data = data.substring(startIndex, endIndex + 1);
            }
        }*/
        if(!data.startsWith("{")){
            int startIndex = data.indexOf("{");
            int endIndex = data.lastIndexOf("}");
            if (startIndex != -1 && endIndex != -1 && endIndex > startIndex) {
                data = data.substring(startIndex, endIndex + 1);
            }
        }
        result.setData(data);
        return result;
    }

}
